﻿// ***********************************************************************
// Assembly         : Delta_webControl
// Author           : Juan Alberto Cerino Gomez
// Created          : 04-25-2013
//
// Last Modified By : Juan Alberto Cerino Gomez
// Last Modified On : 05-28-2013
// ***********************************************************************
// <copyright file="Delta_editor_dato.cs" company="Delta Bussines">
//     Copyright (c) 2013  Delta Bussines. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.UI.WebControls;
using System.Web.UI;
using Delta_webrender.Dynamic;
using Delta_util.Clases;
using Delta_util.Estaticos;
using Delta_control.Base;
using Delta_entidad.EntidadesControl;
using System.Collections;
using Delta_entidad.Atributos;

namespace Delta_webControl.DynamicData
{
    /// <summary>
    /// Clase encargada de generar el formulario de edición de registros de un Delta Grid.
    /// </summary>
    public class Delta_editor_dato : WebControl, INamingContainer
    {
        /// <summary>
        /// Control que sirve para realizar las operaciones a la base de datos.
        /// </summary>
        protected internal object _ctrl = null;

        /// <summary>
        /// The tipo base entidad
        /// </summary>
        protected internal Type tipoBaseEntidad = null;
        /// <summary>
        /// The id
        /// </summary>
        protected internal string id;
        /// <summary>
        /// The id_tabla
        /// </summary>
        protected internal int id_tabla = 0;
        /// <summary>
        /// The folio_tabla
        /// </summary>
        protected internal int folio_tabla = 0;
        /// <summary>
        /// The ref_tabla
        /// </summary>
        protected internal string ref_tabla = null;
        /// <summary>
        /// The fila edicion
        /// </summary>
        protected internal int filaEdicion = 0;
        /// <summary>
        /// The config tabla
        /// </summary>
        protected internal TablaUI configTabla = new TablaUI();

        private StateDeltaEditor EdoControl = new StateDeltaEditor();

        #region Declaracion controles web


        /// <summary>
        /// Update panel para realizar las operaciones asincronas.
        /// </summary>
        protected global::System.Web.UI.UpdatePanel upanelEdit = new UpdatePanel() { ID = "upanelEdit" };
        /// <summary>
        /// Tabla en la que se dibuja el formulario de captura.
        /// </summary>
        protected global::System.Web.UI.WebControls.Table tbCaptura = new Table() { ID = "tbCaptura", ViewStateMode = ViewStateMode.Enabled };
        /// <summary>
        /// Fila donde se colocan los botones de guardar y cancelar.
        /// </summary>
        protected global::System.Web.UI.WebControls.TableRow tbrBotones = new TableRow() { ID = "tbrBotones" };
        /// <summary>
        /// Celda donde se coloca el boton guardar.
        /// </summary>
        protected global::System.Web.UI.WebControls.TableCell tbCellGuardar = new TableCell() { ID = "tbCellGuardar" };
        /// <summary>
        /// Celda donde se coloca el boton cancelar.
        /// </summary>
        protected global::System.Web.UI.WebControls.TableCell tbCellCancelar = new TableCell() { ID = "tbCellCancelar" };
        /// <summary>
        /// Boton que se encarga de guardar los datos.
        /// </summary>
        protected global::System.Web.UI.WebControls.Button btnGuardar = new Button() { ID = "btnGuardar", Text = "Guardar", ClientIDMode = ClientIDMode.Static, OnClientClick = "pkMsgModal('Guardando los datos, espere.....');", ValidationGroup = "validacionEntidad" };
        /// <summary>
        /// Botón para cancelar y cerrar la ventana de edición.
        /// </summary>
        protected global::System.Web.UI.WebControls.Button btnCancelar = new Button() { ID = "btnCancelar", Text = "Cancelar", ClientIDMode = ClientIDMode.Static };
        /// <summary>
        /// Hiiden que guarda en memoria los parametros para la consulta.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HParametros = new HiddenField() { ID = "HParametros" };
        /// <summary>
        /// Etiqueta que muestra el detalle de las excepciones generadas.
        /// </summary>
        protected global::System.Web.UI.WebControls.Label lblError = new Label() { ID = "lblError", CssClass = "error" };
        /// <summary>
        /// Panel el cual contiene la tabla del formulario.
        /// </summary>
        protected global::System.Web.UI.WebControls.Panel pnlEdicion = new Panel() { ID = "pnlEdicion" };
        /// <summary>
        /// Trigger que desencadena el boton guardar.
        /// </summary>
        AsyncPostBackTrigger trgGuardar = new AsyncPostBackTrigger();

        #endregion

        #region Propiedades
        /// <summary>
        /// Obtiene la tabla en la cual se crea el formulario de edición.
        /// </summary>
        /// <value>Componente tabla.</value>
        private Table TablaEdicion
        {
            get { return tbCaptura; }
        }
        /// <summary>
        /// Boton guardar
        /// </summary>
        /// <value>Boton guardar.</value>
        private Button BotonGuardar
        {
            get { return this.btnGuardar; }

        }

        /// <summary>
        /// Obtiene o establece la entidad que se esta editando acutalmente.
        /// </summary>
        /// <value>Entidad con los datos acutales, representada como 'dynamic'.</value>
        private dynamic EntidadEdicion
        {
            get
            {
                return ViewState["EntidadEdicion"];

            }

            set { ViewState["EntidadEdicion"] = value; }
        }

        /// <summary>
        /// Obtiene el atributo de la entidad del tipo actual.
        /// </summary>
        /// <value>Atributo de la entidad.</value>
        internal AttEntidad AtributoProp
        {
            get { return Comun.ObtenerAtributoEntidad<AttEntidad>(tipoBaseEntidad); }
        }

        /// <summary>
        /// Obtiene de la memoria la configuración user del tipo configurado en el Delta Editor, esta configuración se obtiene de la BD.
        /// </summary>
        /// <value>Clase Cat_tipo_gral que contiene la configuración dinamca de los campos.</value>
        protected internal Cat_tipo_gral ConfiguracionUser
        {
            get
            {
                if (EdoControl != null)
                    return EdoControl.DatosConfiguracionDinamica;
                else
                    return null;
            }
        }
        /// <summary>
        /// Indica si se debe usar UpdatePanel o no, recordemos que los updatePanel no trabajan correctamente con algunos componentes como el FileUpload.
        /// </summary>
        /// <value>Valor logico.</value>
        internal bool UsarUpdatePanel
        {
            get
            {
                if (ConfiguracionUser == null && AtributoProp == null)
                    return true;

                bool aplicarConfiguracionWeb = ConfiguracionUser != null && ConfiguracionUser.configuracion_web;

                return aplicarConfiguracionWeb ? ConfiguracionUser.upanel_en_edicion : AtributoProp.usarUpdatePanelEdicion;

            }

        }
        /// <summary>
        /// Boton cancelar
        /// </summary>
        /// <value>Boton cancelar.</value>
        internal Button BotonCancelar
        {
            get { return this.btnCancelar; }

        }
        #endregion


        /// <summary>
        /// Sucede al iniciar la creación del componente <see cref="E:System.Web.UI.Control.Init" />.
        /// </summary>
        /// <param name="e">Objeto <see cref="T:System.EventArgs" /> que contiene los datos del evento.</param>
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            Page.RegisterRequiresControlState(this);
        }

        /// <summary>
        /// Guarda los cambios de estado de un control de servidor que se hayan producido desde el momento en que se devolvieron al servidor los datos de la página.
        /// </summary>
        /// <returns>Devuelve el estado actual del control de servidor.Si no hay ningún estado asociado al método, este método devuelve null.</returns>
        protected override object SaveControlState()
        {

            object obj = base.SaveControlState();

            if (obj != null)
            {
                return new Pair(obj, EdoControl);
            }
            else
            {
                return (EdoControl);
            }

        }

        /// <summary>
        /// Se encarga de cargar el estado del control del servidor.
        /// </summary>
        /// <param name="state">Datos del estado.</param>
        protected override void LoadControlState(object state)
        {
            if (state != null)
            {
                Pair p = state as Pair;
                if (p != null)
                {
                    base.LoadControlState(p.First);
                    EdoControl = (StateDeltaEditor)p.Second;
                }
                else
                {
                    if (state is StateDeltaEditor)
                    {
                        EdoControl = (StateDeltaEditor)state;
                    }
                    else
                    {
                        base.LoadControlState(state);
                    }
                }
            }
        }

        /// <summary>
        /// Imprime las funciones javascript, usada por esta clase.
        /// </summary>
        /// <param name="clave">Es el nombre del Delta Grid que generó este editor.</param>
        protected void ImprimirFunciones(string clave)
        {

            System.Text.StringBuilder strFuncion = new System.Text.StringBuilder();
            //{0} this.uniqueid,{1} btn nuevo unique id

            strFuncion.Append("function CerrarVentana(cambio) {");
            strFuncion.Append("var estatus = cambio;");
            strFuncion.Append("if (cambio == undefined)");
            strFuncion.Append("estatus = getCambio();");
            strFuncion.Append("window.parent.CerrarVentana_{0}(estatus);");
            strFuncion.Append("}");

            Utilerias.ExecScript(this.Page, strFuncion.ToString().Replace("{0}", clave), "ctrlfuncions_" + this.ID);
        }

        /// <summary>
        /// Lo llama el marco de trabajo de las páginas ASP.NET para indicar a los controles de servidor que utilizan la implementación basada en la composición que creen los controles secundarios que contengan como forma de preparar la devolución o representación de los datos.
        /// </summary>
        protected override void CreateChildControls()
        {

            //Configuracion de la tabla
            tbrBotones.Cells.Add(tbCellGuardar);
            tbrBotones.Cells.Add(tbCellCancelar);
            tbCaptura.Rows.Add(tbrBotones);

            //Configuracion del panel
            pnlEdicion.Controls.Add(tbCaptura);
            pnlEdicion.Controls.Add(btnGuardar);
            pnlEdicion.Controls.Add(btnCancelar);
            pnlEdicion.Controls.Add(lblError);
            pnlEdicion.Controls.Add(HParametros);
            //Configuracion del update panel
            upanelEdit.UpdateMode = UpdatePanelUpdateMode.Conditional;
            upanelEdit.ContentTemplateContainer.Controls.Add(pnlEdicion);


            btnGuardar.Attributes.Add("tipo", "boton");
            trgGuardar.ControlID = btnGuardar.ID;
            trgGuardar.EventName = "Click";
            upanelEdit.Triggers.Add(trgGuardar);

            btnCancelar.OnClientClick = "CerrarVentana(false); return false";

            btnGuardar.Click += btnGuardar_Click;

            //if (Page.IsPostBack)
            ConfigurarDatos(null, null);
        }

        /// <summary>
        /// Metodo que configura los datos del editor, este metodo es usado como el Load del componente.
        /// </summary>
        /// <param name="sender">El componente que lo genera.</param>
        /// <param name="ev">La <see cref="EventArgs"/> instancia que contiene los datos del evento.</param>
        /// <exception cref="System.Exception">
        /// No se logro crear el control
        /// <br/>ó
        /// <br/>No se encontraron los datos de la tabla
        /// </exception>
        internal void ConfigurarDatos(object sender, EventArgs ev)
        {
            try
            {

                //this.Page.LoadComplete += new EventHandler(PaginaBase_LoadComplete);
                Utilerias.CerrarNotificacionesModal(this.Page);
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.jdMenu.slate.css"));
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.pkCSS.css"));
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.jquery.window.css"));
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.layout-default-latest.css"));


                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jwindow", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.jquery.window.min.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnoty", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.jquery.noty.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTCenter", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topCenter.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTRight", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topRight.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTLeft", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topLeft.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyDef", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.default.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "core", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.pkCore.js"));
                Utilerias.ExecScript(this.Page, "ConfigurarAjax();", "configAJAX", true);
                string llave = Utilerias.ObtenerValorGET(this.Page, "kv");
                string data = Utilerias.ObtenerValorGET(this.Page, "dat");
                string def = Utilerias.ObtenerValorGET(this.Page, "def");
                filaEdicion = Comun.Convertir<int>(Utilerias.DesEncriptar(Utilerias.ObtenerValorGET(this.Page, "fl"), ConfigProy.claveKey));
                string tp = Utilerias.DesEncriptar(Utilerias.ObtenerValorGET(this.Page, "tp"), ConfigProy.claveKey);

                id = Utilerias.DesEncriptar(llave, ConfigProy.claveKey);
                HiddenField hdata = new HiddenField();
                this.tipoBaseEntidad = Comun.CrearInstancia(tp).GetType();
                ImprimirFunciones(id);
                _ctrl = Comun.ObtnerValorSesion(this.Page, Constantes.claveControl + id);
                if (_ctrl == null)
                {
                    try
                    {

                        //object tipoEntidad = Comun.ObtenerTipo(this.tipoBaseEntidad.Assembly.GetName(true).Name, this.tipoBaseEntidad.FullName);
                        _ctrl = Comun.CrearInstanciaGenerico(typeof(ControlBase<>), tipoBaseEntidad);
                    }
                    catch (Exception ex)
                    {
                        throw new Exception("No se logro crear el control:" + ex.Message);
                    }
                }
                HParametros.Value = def;
                if (ConfiguracionUser == null)
                    EdoControl.DatosConfiguracionDinamica = Comun.ObtenerValorPropiedad<Cat_tipo_gral>(_ctrl, "InformacionUsers");

                Dictionary<string, object> valoresDef = new Dictionary<string, object>();
                if (!string.IsNullOrWhiteSpace(HParametros.Value))
                    valoresDef = Utilerias.DeserializarJsonTo<Dictionary<string, object>>(HParametros, ConfigProy.claveKey);

                configTabla.contenedor = this.ID;
                configTabla.valoresDefault = valoresDef;
                id_tabla = Comun.Convertir<int>(Utilerias.DesEncriptar(Utilerias.ObtenerValorGET(this.Page, "id"), ConfigProy.claveKey));




                if (tipoBaseEntidad == typeof(TablasGral) && EntidadEdicion == null)
                {

                    folio_tabla = Comun.Convertir<int>(Utilerias.DesEncriptar(Utilerias.ObtenerValorGET(this.Page, "f"), ConfigProy.claveKey));
                    ref_tabla = Comun.Convertir<string>(Utilerias.DesEncriptar(Utilerias.ObtenerValorGET(this.Page, "ref"), ConfigProy.claveKey));
                    (_ctrl as ControlBase<TablasGral>).Obtener(new TablasGral() { id_tipo_gral = id_tabla, folio = folio_tabla, referencia1 = ref_tabla });
                    EntidadEdicion = (_ctrl as ControlBase<TablasGral>).Dato;
                    Comun.EjecutarMetodoObjGet(_ctrl, "CargarConfiguracionUser", null, id_tabla);
                    EdoControl.DatosConfiguracionDinamica = Comun.ObtenerValorPropiedad<Cat_tipo_gral>(_ctrl, "InformacionUsers");
                    configTabla.configUsers = ConfiguracionUser.campos.ToList<dynamic>();
                    configTabla.tipo = null;
                    if (filaEdicion > 0)
                        configTabla.Entidad = (_ctrl as dynamic).ObtenerDatosItemGral(filaEdicion);
                }
                else
                {
                    configTabla.Entidad = EntidadEdicion;
                    if (ConfiguracionUser != null && ConfiguracionUser.campos != null)
                        configTabla.configUsers = ConfiguracionUser.campos.ToList<dynamic>();
                    else
                        configTabla.configUsers = null;
                    if (configTabla.configUsers == null || configTabla.configUsers.Count == 0)
                    {
                        Comun.EjecutarMetodoObjGet(_ctrl, "CargarConfiguracionUser", tipoBaseEntidad, id_tabla > 0 ? id_tabla : -1);
                        EdoControl.DatosConfiguracionDinamica = Comun.ObtenerValorPropiedad<Cat_tipo_gral>(_ctrl, "InformacionUsers");
                        if (ConfiguracionUser != null && ConfiguracionUser.campos != null)
                            configTabla.configUsers = ConfiguracionUser.campos.ToList<dynamic>();
                        else
                            configTabla.configUsers = null;
                    }
                    configTabla.tipo = tipoBaseEntidad == typeof(TablasGral) ? null : tipoBaseEntidad;
                }

                if (UsarUpdatePanel)
                    this.Controls.Add(upanelEdit);
                else
                    this.Controls.Add(pnlEdicion);

                if (!Page.IsPostBack)
                {
                    if (!string.IsNullOrWhiteSpace(data) && EntidadEdicion == null)
                    {
                        hdata.Value = data;
                        Hashtable parametros = Utilerias.DeserializarJsonTo<Hashtable>(hdata, ConfigProy.claveKey);
                        if (parametros != null && parametros.Count > 0)
                        {

                            object datosObtener = Comun.CrearInstancia(tipoBaseEntidad);
                            Comun.RellenarEntidad(parametros, datosObtener);
                            Comun.EjecutarMetodoObj(_ctrl, "Obtener", datosObtener);
                            EntidadEdicion = Comun.ObtenerValorPropiedad(_ctrl, "Dato");
                        }
                    }
                    else if (EntidadEdicion == null)
                        EntidadEdicion = Comun.ObtnerValorSesion(this.Page, Constantes.claveEntidad + id);

                    if (tipoBaseEntidad == typeof(TablasGral) && EntidadEdicion == null)
                    {
                        throw new Exception("No se encontraron los datos de la tabla");
                    }

                    Comun.FijarValorSesion(this.Page, Constantes.claveEntidad + id, null);

                }


                if (tipoBaseEntidad == typeof(TablasGral) && EntidadEdicion == null)
                {
                    //if (filaEdicion > 0)
                    //    configTabla.Entidad = (_ctrl as dynamic).ObtenerDatosItemGral(filaEdicion);

                    if (EntidadEdicion != null)
                        configTabla.CrearPanelCaptura(tbCaptura, this.Page);

                }
                else
                {
                    configTabla.Entidad = EntidadEdicion;
                    configTabla.CrearPanelCaptura(tbCaptura, this.Page);
                }

                if (!Page.IsPostBack)
                {
                    if (EntidadEdicion != null)
                    {
                        if (tipoBaseEntidad == typeof(TablasGral) && filaEdicion > 0)
                        {
                            configTabla.RellenarTabla(tbCaptura, (_ctrl as dynamic).ObtenerDatosItemGral(filaEdicion));
                            configTabla.RellenarControl(this, (_ctrl as dynamic).ObtenerDatosItemGral(filaEdicion));
                        }
                        else
                        {
                            configTabla.RellenarTabla(tbCaptura, EntidadEdicion);
                            configTabla.RellenarControl(this, EntidadEdicion);
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                lblError.Text = "Error en la pagina:" + Utilerias.getMsgError(ex);
                pnlEdicion.Enabled = false;

            }
        }
        /// <summary>
        /// Handle del evento Click del boton guardar
        /// </summary>
        /// <param name="sender">El componente que lo genera.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia que contiene los datos del evento.</param>
        protected void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                Page.Validate("validacionEntidad");
                (_ctrl as dynamic).AsignarInformacionDinamica(ConfiguracionUser);
                if (Page.IsValid)
                {
                    object EntidadGuardar = EntidadEdicion;

                    if (tipoBaseEntidad == typeof(TablasGral))
                    {
                        Comun.FijarValorObjeto(_ctrl, EntidadGuardar, "Dato");
                        List<ItemGral> listado = (_ctrl as ControlBase<TablasGral>).ObtenerListadoTablaXML();
                        dynamic itemEdicion = null;
                        if (filaEdicion > 0)
                            itemEdicion = listado[filaEdicion - 1];
                        else
                        {
                            itemEdicion = new ItemGral();

                            itemEdicion.FijarConfiguracionDinamica(ConfiguracionUser);
                            itemEdicion.id_tabla_gral = (EntidadGuardar as TablasGral).id_tabla_gral;
                            itemEdicion.id_tipo_gral = (EntidadGuardar as TablasGral).id_tipo_gral;
                        }

                        configTabla.RellenarEntidad(tbCaptura, ref itemEdicion);
                        (EntidadEdicion as TablasGral).InsertarFila(itemEdicion, filaEdicion);
                        EntidadEdicion = EntidadGuardar;
                    }
                    else
                    {
                        if (EntidadGuardar == null)
                        {
                            Comun.EjecutarMetodoObj(_ctrl, "CrearEntidad");
                            EntidadGuardar = Comun.ObtenerValorPropiedad(_ctrl, "Dato");

                        }
                        configTabla.RellenarEntidad(tbCaptura, ref EntidadGuardar);

                    }

                    Comun.EjecutarMetodoObj(_ctrl, "Insertar", EntidadGuardar, true);
                    EntidadEdicion = EntidadGuardar;
                    Utilerias.ExecScript(this.Page, string.Format("window.parent.cambio_{0}=true;", id), "avisarCambio", true);
                    Utilerias.ExecScript(this.Page, "CerrarVentana(true);", "cerrar");

                }
                else
                    lblError.Text = "Hay campos no validos.";
            }
            catch (Exception ex)
            {
                lblError.Text = "No se logro guardar los datos:" + Utilerias.getMsgError(ex);

            }
        }
    }
}
